#angular applications

[infutivetechnologies]

Top Mobile App Development Company in Delhi: Why Infutive Leads the Way

There is a need for businesses to get an assured App Development Company in Delhi like Infutive, that help them expand their digital presence using mobile applications, if they wish to compete in the market. As the world continues to become more mobile-centric, companies in every industry are acquiring app development services to boost customer engagement, operational efficiency, and the ability to compete in their respective sectors.

Infutive is a leading name when it comes to creative, easy-to-use, and scalable mobile app development that is customised as per our clients’ requirements.

Innovative Mobile App Development Company in India

Being the top leader in the best mobile app development company in India, Infutive uses the best tech stack to create powerful apps that offers function and style. With Android and iOS apps as well as cross-platform solutions, the agency develops performing applications that represent the brand. Whether it's their e-commerce platform, their service booking app, or a data-driven enterprise tool, Infutive makes sure every app not only presents top-notch quality in execution, but also in design and user experience.

This development includes collaborating with clients from the get-go, so that every aspect they develop aligns with business goals. Infutive creates a finished product and has a strong support system from the wireframes to the end of the deployment.

What Makes Infutive a Leader in App Developers in India

Infutive has a specialised team of best app developers in India. The amount of creativity, problem-solving and coding skills they bring to each piece varies. The team also keeps up to date with new technology trends and features on the market, such as Flutter, React Native, Swift and Kotlin, in order to provide their customers with the most modern and in demand products.

Agile development methodology allows delivering on time and remain flexible to everything that comes up. Whether you are a start-up with a new concept, or a company looking to digitise products or services, Infutive’s developers build solutions that are practical.

Why to Choose Infutive as Your Mobile App Partner?

Infutive isn’t in the business of just making apps — it’s building lasting, growth-focused relationships. They are acclaimed as a reputed App Development Company in Delhi and are widely known to provide the best app development services. Their open-minded approach to our needs, rich detailing and post-launch support makes them a go-to technology partner for many companies in India and overseas.

Talk soon on making your app idea a reality. Discover smart, cloud-based mobile app development that’s built for business.

[jcmarchi]

Compiling CSS With Vite and Lightning CSS

New Post has been published on https://thedigitalinsider.com/compiling-css-with-vite-and-lightning-css/

Compiling CSS With Vite and Lightning CSS

Suppose you follow CSS feature development as closely as we do here at CSS-Tricks. In that case, you may be like me and eager to use many of these amazing tools but find browser support sometimes lagging behind what might be considered “modern” CSS (whatever that means).

Even if browser vendors all have a certain feature released, users might not have the latest versions!

We can certainly plan for this a number of ways:

feature detection with @supports

progressively enhanced designs

polyfills

For even extra help, we turn to build tools. Chances are, you’re already using some sort of build tool in your projects today. CSS developers are most likely familiar with CSS pre-processors (such as Sass or Less), but if you don’t know, these are tools capable of compiling many CSS files into one stylesheet. CSS pre-processors help make organizing CSS a lot easier, as you can move parts of CSS into related folders and import things as needed.

Pre-processors do not just provide organizational superpowers, though. Sass gave us a crazy list of features to work with, including:

extends

functions

loops

mixins

nesting

variables

…more, probably!

For a while, this big feature set provided a means of filling gaps missing from CSS, making Sass (or whatever preprocessor you fancy) feel like a necessity when starting a new project. CSS has evolved a lot since the release of Sass — we have so many of those features in CSS today — so it doesn’t quite feel that way anymore, especially now that we have native CSS nesting and custom properties.

Along with CSS pre-processors, there’s also the concept of post-processing. This type of tool usually helps transform compiled CSS in different ways, like auto-prefixing properties for different browser vendors, code minification, and more. PostCSS is the big one here, giving you tons of ways to manipulate and optimize your code, another step in the build pipeline.

In many implementations I’ve seen, the build pipeline typically runs roughly like this:

Generate static assets

Build application files

Bundle for deployment

CSS is usually handled in that first part, which includes running CSS pre- and post-processors (though post-processing might also happen after Step 2). As mentioned, the continued evolution of CSS makes it less necessary for a tool such as Sass, so we might have an opportunity to save some time.

Vite for CSS

Awarded “Most Adopted Technology” and “Most Loved Library” from the State of JavaScript 2024 survey, Vite certainly seems to be one of the more popular build tools available. Vite is mainly used to build reactive JavaScript front-end frameworks, such as Angular, React, Svelte, and Vue (made by the same developer, of course). As the name implies, Vite is crazy fast and can be as simple or complex as you need it, and has become one of my favorite tools to work with.

Vite is mostly thought of as a JavaScript tool for JavaScript projects, but you can use it without writing any JavaScript at all. Vite works with Sass, though you still need to install Sass as a dependency to include it in the build pipeline. On the other hand, Vite also automatically supports compiling CSS with no extra steps. We can organize our CSS code how we see fit, with no or very minimal configuration necessary. Let’s check that out.

We will be using Node and npm to install Node packages, like Vite, as well as commands to run and build the project. If you do not have node or npm installed, please check out the download page on their website.

Navigate a terminal to a safe place to create a new project, then run:

npm create vite@latest

The command line interface will ask a few questions, you can keep it as simple as possible by choosing Vanilla and JavaScript which will provide you with a starter template including some no-frameworks-attached HTML, CSS, and JavaScript files to help get you started.

Before running other commands, open the folder in your IDE (integrated development environment, such as VSCode) of choice so that we can inspect the project files and folders.

If you would like to follow along with me, delete the following files that are unnecessary for demonstration:

assets/

public/

src/

.gitignore

We should only have the following files left in out project folder:

index.html

package.json

Let’s also replace the contents of index.html with an empty HTML template:

<!doctype html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>CSS Only Vite Project</title> </head> <body> <!-- empty for now --> </body> </html>

One last piece to set up is Vite’s dependencies, so let’s run the npm installation command:

npm install

A short sequence will occur in the terminal. Then we’ll see a new folder called node_modules/ and a package-lock.json file added in our file viewer.

node_modules is used to house all package files installed through node package manager, and allows us to import and use installed packages throughout our applications.

package-lock.json is a file usually used to make sure a development team is all using the same versions of packages and dependencies.

We most likely won’t need to touch these things, but they are necessary for Node and Vite to process our code during the build. Inside the project’s root folder, we can create a styles/ folder to contain the CSS we will write. Let’s create one file to begin with, main.css, which we can use to test out Vite.

├── public/ ├── styles/ | └── main.css └──index.html

In our index.html file, inside the <head> section, we can include a <link> tag pointing to the CSS file:

<head> <meta charset="UTF-8" /> <link rel="icon" type="image/svg+xml" href="/vite.svg" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>CSS Only Vite Project</title> <!-- Main CSS --> <link rel="stylesheet" href="styles/main.css"> </head>

Let’s add a bit of CSS to main.css:

body background: green;

It’s not much, but it’s all we’ll need at the moment! In our terminal, we can now run the Vite build command using npm:

npm run build

With everything linked up properly, Vite will build things based on what is available within the index.html file, including our linked CSS files. The build will be very fast, and you’ll be returned to your terminal prompt.

Vite will provide a brief report, showcasing the file sizes of the compiled project.

The newly generated dist/ folder is Vite’s default output directory, which we can open and see our processed files. Checking out assets/index.css (the filename will include a unique hash for cache busting), and you’ll see the code we wrote, minified here.

Now that we know how to make Vite aware of our CSS, we will probably want to start writing more CSS for it to compile.

As quick as Vite is with our code, constantly re-running the build command would still get very tedious. Luckily, Vite provides its own development server, which includes a live environment with hot module reloading, making changes appear instantly in the browser. We can start the Vite development server by running the following terminal command:

npm run dev

Vite uses the default network port 5173 for the development server. Opening the http://localhost:5137/ address in your browser will display a blank screen with a green background.

Adding any HTML to the index.html or CSS to main.css, Vite will reload the page to display changes. To stop the development server, use the keyboard shortcut CTRL+C or close the terminal to kill the process.

At this point, you pretty much know all you need to know about how to compile CSS files with Vite. Any CSS file you link up will be included in the built file.

Organizing CSS into Cascade Layers

One of the items on my 2025 CSS Wishlist is the ability to apply a cascade layer to a link tag. To me, this might be helpful to organize CSS in a meaningful ways, as well as fine control over the cascade, with the benefits cascade layers provide. Unfortunately, this is a rather difficult ask when considering the way browsers paint styles in the viewport. This type of functionality is being discussed between the CSS Working Group and TAG, but it’s unclear if it’ll move forward.

With Vite as our build tool, we can replicate the concept as a way to organize our built CSS. Inside the main.css file, let’s add the @layer at-rule to set the cascade order of our layers. I’ll use a couple of layers here for this demo, but feel free to customize this setup to your needs.

/* styles/main.css */ @layer reset, layouts;

This is all we’ll need inside our main.css, let’s create another file for our reset. I’m a fan of my friend Mayank‘s modern CSS reset, which is available as a Node package. We can install the reset by running the following terminal command:

npm install @acab/reset.css

Now, we can import Mayank’s reset into our newly created reset.css file, as a cascade layer:

/* styles/reset.css */ @import '@acab/reset.css' layer(reset);

If there are any other reset layer stylings we want to include, we can open up another @layer reset block inside this file as well.

/* styles/reset.css */ @import '@acab/reset.css' layer(reset); @layer reset /* custom reset styles */

This @import statement is used to pull packages from the node_modules folder. This folder is not generally available in the built, public version of a website or application, so referencing this might cause problems if not handled properly.

Now that we have two files (main.css and reset.css), let’s link them up in our index.html file. Inside the <head> tag, let’s add them after <title>:

<head> <meta charset="UTF-8" /> <link rel="icon" type="image/svg+xml" href="/vite.svg" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>CSS Only Vite Project</title> <link rel="stylesheet" href="styles/main.css"> <link rel="stylesheet" href="styles/reset.css"> </head>

The idea here is we can add each CSS file, in the order we need them parsed. In this case, I’m planning to pull in each file named after the cascade layers setup in the main.css file. This may not work for every setup, but it is a helpful way to keep in mind the precedence of how cascade layers affect computed styles when rendered in a browser, as well as grouping similarly relevant files.

Since we’re in the index.html file, we’ll add a third CSS <link> for styles/layouts.css.

<head> <meta charset="UTF-8" /> <link rel="icon" type="image/svg+xml" href="/vite.svg" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>CSS Only Vite Project</title> <link rel="stylesheet" href="styles/main.css"> <link rel="stylesheet" href="styles/reset.css"> <link rel="stylesheet" href="styles/layouts.css"> </head>

Create the styles/layouts.css file with the new @layer layouts declaration block, where we can add layout-specific stylings.

/* styles/layouts.css */ @layer layouts /* layouts styles */

For some quick, easy, and awesome CSS snippets, I tend to refer to Stephanie Eckles‘ SmolCSS project. Let’s grab the “Smol intrinsic container” code and include it within the layouts cascade layer:

/* styles/layouts.css */ @layer layouts .smol-container width: min(100% - 3rem, var(--container-max, 60ch)); margin-inline: auto;

This powerful little, two-line container uses the CSS min() function to provide a responsive width, with margin-inline: auto; set to horizontally center itself and contain its child elements. We can also dynamically adjust the width using the --container-max custom property.

Now if we re-run the build command npm run build and check the dist/ folder, our compiled CSS file should contain:

Our cascade layer declarations from main.css

Mayank’s CSS reset fully imported from reset.css

The .smol-container class added from layouts.csss

As you can see, we can get quite far with Vite as our build tool without writing any JavaScript. However, if we choose to, we can extend our build’s capabilities even further by writing just a little bit of JavaScript.

Post-processing with LightningCSS

Lightning CSS is a CSS parser and post-processing tool that has a lot of nice features baked into it to help with cross-compatibility among browsers and browser versions. Lightning CSS can transform a lot of modern CSS into backward-compatible styles for you.

We can install Lightning CSS in our project with npm:

npm install --save-dev lightningcss

The --save-dev flag means the package will be installed as a development dependency, as it won’t be included with our built project. We can include it within our Vite build process, but first, we will need to write a tiny bit of JavaScript, a configuration file for Vite. Create a new file called: vite.config.mjs and inside add the following code:

// vite.config.mjs export default css: transformer: 'lightningcss' , build: cssMinify: 'lightningcss' ;

Vite will now use LightningCSS to transform and minify CSS files. Now, let’s give it a test run using an oklch color. Inside main.css let’s add the following code:

/* main.css */ body background-color: oklch(51.98% 0.1768 142.5);

Then re-running the Vite build command, we can see the background-color property added in the compiled CSS:

/* dist/index.css */ body background-color: green; background-color: color(display-p3 0.216141 0.494224 0.131781); background-color: lab(46.2829% -47.5413 48.5542);

Lightning CSS converts the color white providing fallbacks available for browsers which might not support newer color types. Following the Lightning CSS documentation for using it with Vite, we can also specify browser versions to target by installing the browserslist package.

Browserslist will give us a way to specify browsers by matching certain conditions (try it out online!)

npm install -D browserslist

Inside our vite.config.mjs file, we can configure Lightning CSS further. Let’s import the browserslist package into the Vite configuration, as well as a module from the Lightning CSS package to help us use browserlist in our config:

// vite.config.mjs import browserslist from 'browserslist'; import browserslistToTargets from 'lightningcss';

We can add configuration settings for lightningcss, containing the browser targets based on specified browser versions to Vite’s css configuration:

// vite.config.mjs import browserslist from 'browserslist'; import browserslistToTargets from 'lightningcss'; export default css: transformer: 'lightningcss', lightningcss: targets: browserslistToTargets(browserslist('>= 0.25%')), , build: cssMinify: 'lightningcss' ;

There are lots of ways to extend Lightning CSS with Vite, such as enabling specific features, excluding features we won’t need, or writing our own custom transforms.

// vite.config.mjs import browserslist from 'browserslist'; import browserslistToTargets, Features from 'lightningcss'; export default css: transformer: 'lightningcss', lightningcss: targets: browserslistToTargets(browserslist('>= 0.25%')), // Including `light-dark()` and `colors()` functions include: Features.LightDark , build: cssMinify: 'lightningcss' ;

For a full list of the Lightning CSS features, check out their documentation on feature flags.

Is any of this necessary?

Reading through all this, you may be asking yourself if all of this is really necessary. The answer: absolutely not! But I think you can see the benefits of having access to partialized files that we can compile into unified stylesheets.

I doubt I’d go to these lengths for smaller projects, however, if building something with more complexity, such as a design system, I might reach for these tools for organizing code, cross-browser compatibility, and thoroughly optimizing compiled CSS.

[gagande]

PureCode software reviews | Angular’s choice to use real DOM

React and Vue’s use of a virtual DOM minimizes direct manipulation of the real DOM, thus accelerating and optimizing updates. On the other hand, Angular’s choice to use real DOM may negatively impact performance, particularly in large-scale and complex applications where DOM updates are frequent and heavy.

[softweb-solutions]

Angular has emerged as the go-to framework for e-commerce development due to its scalability, performance, and security features. This blog explores how Angular's component-based architecture, built-in SEO support, and cross-platform development capabilities make it ideal for creating fast, responsive, and secure e-commerce platforms. With its low code framework and faster time to market, businesses can efficiently handle large product catalogs and high traffic while reducing development costs. Whether it's improving customer engagement, boosting security, or ensuring SEO success, Angular provides the robust foundation needed for modern e-commerce success.

[precisiotech]

Angular Programmers| Precisio Technologies

At Precisio Technologies, our team of expert Angular programmers is dedicated to delivering top-notch web applications that meet the highest standards of performance and user experience. Our Angular programmers leverage the latest features and best practices to create dynamic, responsive, and scalable solutions tailored to your business needs. Trust Precisio Technologies to provide skilled Angular programmers who bring your vision to life with precision and efficiency.

Read More-

[albertyevans]

Looking for application development? Check out the strong reasons to choose Angular for your web application development.

[covrize123]

Types of Applications build with Angular

This content provides an overview of Angular as a front-end technology and compares it with React. It emphasizes that the choice of front-end technology should align with the specific needs of your business and the application being developed.

The article outlines the advantages and disadvantages of Angular, focusing on its component-based architecture, two-way data binding, TypeScript integration, and robust ecosystem as key strengths, but also mentions its steep learning curve and potential performance overhead for simpler applications.

It then lists the types of applications best suited for Angular, such as:

Enterprise-Level Web Applications: Angular's modularity supports scalability and complex interfaces.

2. Single-Page Applications (SPAs): It enables dynamic, seamless user experiences.

3. Progressive Web Applications (PWAs): Offers offline capabilities and a native-like user experience.

4. Cross-Platform Applications: Tools like Ionic and NativeScript make Angular suitable for iOS and Android development.

5. Data-Driven Applications: Angular excels in real-time data updates and dynamic views.

6. Enterprise Resource Planning (ERP) Systems: Its architecture supports modularity and workflow management.

7. E-commerce Platforms: Angular facilitates dynamic product catalogues and secure transactions.

8. Content Management Systems (CMS): Component-based architecture enhances content editing and publishing.

9. Financial Applications: Its strong security features and real-time data handling make it ideal for this sector.

The content concludes by advising businesses to choose technologies thoughtfully, factoring in both current and future needs, and suggests seeking expert advice before deciding.

Lastly, it introduces a provider of skilled Angular developers who can create business applications tailored to specific industries.

[glasierinc]

Best Practices For Securing SaaS Applications With Workflow Apps.

Read Full Blog Hear,

Visit Website, Glasier Inc.

Our Blogs

Other Services,

hospital management system

erp software development company

Hire Angular Developers

Hire SaaS developer

Hire Flutter Developers

Hire ReactJs Developers

[bluerocket111]

Need Angular JS development services that really hit the mark? Blue Rocket has you covered. We’re experts in delivering fast, dynamic, and user-friendly applications using Angular JS. Our team at Blue Rocket knows how to get the most out of this powerful framework, ensuring your project runs smoothly from start to finish. When you choose us for Angular JS development services, you’re choosing quality, reliability, and a team that truly cares about your success.

[ahex-technologies]

Testing AngularJS Applications: Tools and Techniques for 2024

In 2024, testing AngularJS applications has become more streamlined and crucial for maintaining robust applications. Whether you're an AngularJS development company or an individual AngularJS developer in India, understanding the tools and techniques for effective testing is essential. This article delves into the best practices and tools available to ensure your Angular application is both reliable and efficient.

Understanding AngularJS Testing: Unit vs. End-to-End

There are two main types of AngularJS testing: unit testing and end-to-end testing. Unit testing is the process of testing small and isolated pieces of code (modules) in your Angular application. This provides an added advantage to the users as they can add any new features without breaking any other part of their application. End-to-end testing is verifying that the entire application behaves as expected.

Tools for Effective Testing

There are a variety of tools available for Angular testing, such as:

Jasmine: A behavior-driven development framework for testing JavaScript code. It does not depend on any other JavaScript framework and does not require DOM manipulation.

Karma: A JavaScript test runner that can be used to run Jasmine tests in a browser. It provides an easy way to set up and run tests, and it can be used to run tests on multiple browsers.

Protractor: An end-to-end testing framework for Angular applications. It runs tests against your application running in a real browser, interacting with it as a user would. Protractor supports Angular-specific locator strategies, which allows you to test Angular-specific elements without any setup effort on your part.

Implementing Testing Strategies To test an AngularJS application, you will need to install the necessary tools and create a test suite. The test suite will contain a set of tests that verify the functionality of your application. You can run the tests using a test runner, such as Karma or Protractor.

Best Practices for Testing Here are some tips for testing AngularJS applications:

Start with unit tests. Unit tests are the easiest to write and maintain, and they can help you to identify problems early on. Use a test runner. A test runner can help you to run your tests easily and efficiently. Test your application in multiple browsers. This will help you to ensure that your application works as expected in all of the browsers that your users are likely to use. Use a continuous integration server. A continuous integration server can help you to automate your testing process and to ensure that your application is always tested before it is deployed.

Conclusion Effective testing is pivotal for the success of any AngularJS development services. By leveraging tools like Jasmine, Karma, and Protractor, and adhering to best practices, developers can ensure their Angular UX/UI development services deliver high-quality, bug-free applications. Whether you are an AngularJS development company or hiring AngularJS developers in India, these testing strategies will help maintain the integrity and performance of your applications in 2024 and beyond.

[jcmarchi]

Sapiens: Foundation for Human Vision Models

New Post has been published on https://thedigitalinsider.com/sapiens-foundation-for-human-vision-models/

Sapiens: Foundation for Human Vision Models

The remarkable success of large-scale pretraining followed by task-specific fine-tuning for language modeling has established this approach as a standard practice. Similarly, computer vision methods are progressively embracing extensive data scales for pretraining. The emergence of large datasets, such as LAION5B, Instagram-3.5B, JFT-300M, LVD142M, Visual Genome, and YFCC100M, has enabled the exploration of a data corpus well beyond the scope of traditional benchmarks. Salient work in this domain includes DINOv2, MAWS, and AIM. DINOv2 achieves state-of-the-art performance in generating self-supervised features by scaling the contrastive iBot method on the LDV-142M dataset. MAWS studies the scaling of masked-autoencoders (MAE) on billion images. AIM explores the scalability of autoregressive visual pretraining similar to BERT for vision transformers. In contrast to these methods, which mainly focus on general image pretraining or zero-shot image classification, Sapiens takes a distinctly human-centric approach: Sapiens’ models leverage a vast collection of human images for pretraining, subsequently fine-tuning for a range of human-related tasks. The pursuit of large-scale 3D human digitization remains a pivotal goal in computer vision. 

Significant progress has been made within controlled or studio environments, yet challenges persist in extending these methods to unconstrained environments. To address these challenges, developing versatile models capable of multiple fundamental tasks, such as key popoint estimation, body-part segmentation, depth estimation, and surface normal prediction from images in natural settings, is crucial. In this work, Sapiens aims to develop models for these essential human vision tasks that generalize to in-the-wild settings. Currently, the largest publicly accessible language models contain upwards of 100B parameters, while the more commonly used language models contain around 7B parameters. In contrast, Vision Transformers (ViT), despite sharing a similar architecture, have not been scaled to this extent successfully. While there are notable endeavors in this direction, including the development of a dense ViT-4B trained on both text and images, and the formulation of techniques for the stable training of a ViT-22B, commonly utilized vision backbones still range between 300M to 600M parameters and are primarily pre-trained at an image resolution of about 224 pixels. Similarly, existing transformer-based image generation models, such as DiT, use less than 700M parameters and operate on a highly compressed latent space. To address this gap, Sapiens introduces a collection of large, high-resolution ViT models that are pretrained natively at a 1024-pixel image resolution on millions of human images. 

Sapiens presents a family of models for four fundamental human-centric vision tasks: 2D pose estimation, body-part segmentation, depth estimation, and surface normal prediction. Sapiens models natively support 1K high-resolution inference and are extremely easy to adapt for individual tasks by simply fine-tuning models pretrained on over 300 million in-the-wild human images. Sapiens observes that, given the same computational budget, self-supervised pre-training on a curated dataset of human images significantly boosts performance for a diverse set of human-centric tasks. The resulting models exhibit remarkable generalization to in-the-wild data, even when labeled data is scarce or entirely synthetic. The simple model design also brings scalability—model performance across tasks improves as the number of parameters scales from 0.3 to 2 billion. Sapiens consistently surpasses existing baselines across various human-centric benchmarks, achieving significant improvements over prior state-of-the-art results: 7.6 mAP on Humans-5K (pose), 17.1 mIoU on Humans-2K (part-seg), 22.4% relative RMSE on Hi4D (depth), and 53.5% relative angular error on THuman2 (normal). 

Recent years have witnessed remarkable strides toward generating photorealistic humans in 2D and 3D. The success of these methods is greatly attributed to the robust estimation of various assets such as 2D key points, fine-grained body-part segmentation, depth, and surface normals. However, robust and accurate estimation of these assets remains an active research area, and complicated systems to boost performance for individual tasks often hinder wider adoption. Moreover, obtaining accurate ground-truth annotation in-the-wild is notoriously difficult to scale. Sapiens’ goal is to provide a unified framework and models to infer these assets in-the-wild, unlocking a wide range of human-centric applications for everyone.

Sapiens argues that such human-centric models should satisfy three criteria: generalization, broad applicability, and high fidelity. Generalization ensures robustness to unseen conditions, enabling the model to perform consistently across varied environments. Broad applicability indicates the versatility of the model, making it suitable for a wide range of tasks with minimal modifications. High fidelity denotes the ability of the model to produce precise, high-resolution outputs, essential for faithful human generation tasks. This paper details the development of models that embody these attributes, collectively referred to as Sapiens.

Following insights, Sapiens leverages large datasets and scalable model architectures, key for generalization. For broader applicability, Sapiens adopts the pretrain-then-finetune approach, enabling post-pretraining adaptation to specific tasks with minimal adjustments. This approach raises a critical question: What type of data is most effective for pretraining? Given computational limits, should the emphasis be on collecting as many human images as possible, or is it preferable to pretrain on a less curated set to better reflect real-world variability? Existing methods often overlook the pretraining data distribution in the context of downstream tasks. To study the influence of pretraining data distribution on human-specific tasks, Sapiens collects the Humans-300M dataset, featuring 300 million diverse human images. These un-labelled images are used to pre-train a family of vision transformers from scratch, with parameter counts ranging from 300M to 2B.

Among various self-supervision methods for learning general-purpose visual features from large datasets, Sapiens chooses the masked-autoencoder (MAE) approach for its simplicity and efficiency in pretraining. MAE, having a single-pass inference model compared to contrastive or multi-inference strategies, allows processing a larger volume of images with the same computational resources. For higher fidelity, in contrast to prior methods, Sapiens increases the native input resolution of its pretraining to 1024 pixels, resulting in approximately a 4× increase in FLOPs compared to the largest existing vision backbone. Each model is pretrained on 1.2 trillion tokens. For fine-tuning on human-centric tasks, Sapiens uses a consistent encoder-decoder architecture. The encoder is initialized with weights from pretraining, while the decoder, a lightweight and task-specific head, is initialized randomly. Both components are then fine-tuned end-to-end. Sapiens focuses on four key tasks: 2D pose estimation, body-part segmentation, depth, and normal estimation, as demonstrated in the following figure. 

Consistent with prior studies, Sapiens affirms the critical impact of label quality on the model’s in-the-wild performance. Public benchmarks often contain noisy labels, providing inconsistent supervisory signals during model fine-tuning. At the same time, it is important to utilize fine-grained and precise annotations to align closely with Sapiens’ primary goal of 3D human digitization. To this end, Sapiens proposes a substantially denser set of 2D whole-body key points for pose estimation and a detailed class vocabulary for body part segmentation, surpassing the scope of previous datasets. Specifically, Sapiens introduces a comprehensive collection of 308 key points encompassing the body, hands, feet, surface, and face. Additionally, Sapiens expands the segmentation class vocabulary to 28 classes, covering body parts such as the hair, tongue, teeth, upper/lower lip, and torso. To guarantee the quality and consistency of annotations and a high degree of automation, Sapiens utilizes a multi-view capture setup to collect pose and segmentation annotations. Sapiens also utilizes human-centric synthetic data for depth and normal estimation, leveraging 600 detailed scans from RenderPeople to generate high-resolution depth maps and surface normals. Sapiens demonstrates that the combination of domain-specific large-scale pretraining with limited, yet high-quality annotations leads to robust in-the-wild generalization. Overall, Sapiens’ method shows an effective strategy for developing highly precise discriminative models capable of performing in real-world scenarios without the need for collecting a costly and diverse set of annotations.

Sapiens : Method and Architecture

Sapiens follows the masked-autoencoder (MAE) approach for pretraining. The model is trained to reconstruct the original human image given its partial observation. Like all autoencoders, Sapiens’ model has an encoder that maps the visible image to a latent representation and a decoder that reconstructs the original image from this latent representation. The pretraining dataset consists of both single and multi-human images, with each image resized to a fixed size with a square aspect ratio. Similar to ViT, the image is divided into regular non-overlapping patches with a fixed patch size. A subset of these patches is randomly selected and masked, leaving the rest visible. The proportion of masked patches to visible ones, known as the masking ratio, remains fixed throughout training.

Sapiens’ models exhibit generalization across a variety of image characteristics, including scales, crops, the age and ethnicity of subjects, and the number of subjects. Each patch token in the model accounts for 0.02% of the image area compared to 0.4% in standard ViTs, a 16× reduction—providing fine-grained inter-token reasoning for the models. Even with an increased mask ratio of 95%, Sapiens’ model achieves a plausible reconstruction of human anatomy on held-out samples. The reconstruction of Sapien’s pre-trained model on unseen human images is demonstrated in the following image. 

Furthermore, Sapiens utilizes a large proprietary dataset for pretraining, consisting of approximately 1 billion in-the-wild images, focusing exclusively on human images. The preprocessing involves discarding images with watermarks, text, artistic depictions, or unnatural elements. Sapiens then uses an off-the-shelf person bounding-box detector to filter images, retaining those with a detection score above 0.9 and bounding box dimensions exceeding 300 pixels. Over 248 million images in the dataset contain multiple subjects. 

2D Pose Estimation

The Sapien framework finetunes the encoder and decoder in P across multiple skeletons, including K = 17 [67], K = 133 [55] and a new highly-detailed skeleton, with K = 308, as shown in the following figure.

Compared to existing formats with at most 68 facial key points, Sapien’s annotations consist of 243 facial key points, including representative points around the eyes, lips, nose, and ears. This design is tailored to meticulously capture the nuanced details of facial expressions in the real world. With these key points, the Sapien framework manually annotated 1 million images at 4K resolution from an indoor capture setup. Similar to previous tasks, we set the decoder output channels of the normal estimator N to be 3, corresponding to the xyz components of the normal vector at each pixel. The generated synthetic data is also used as supervision for surface normal estimation.

Sapien : Experiment and Results

Sapiens-2B is pretrained using 1024 A100 GPUs for 18 days with PyTorch. Sapiens uses the AdamW optimizer for all experiments. The learning schedule includes a brief linear warm-up, followed by cosine annealing for pretraining and linear decay for finetuning. All models are pretrained from scratch at a resolution of 1024 × 1024 with a patch size of 16. For finetuning, the input image is resized to a 4:3 ratio, i.e., 1024 × 768. Sapiens applies standard augmentations like cropping, scaling, flipping, and photometric distortions. A random background from non-human COCO images is added for segmentation, depth, and normal prediction tasks. Importantly, Sapiens uses differential learning rates to preserve generalization, with lower learning rates for initial layers and progressively higher rates for subsequent layers. The layer-wise learning rate decay is set to 0.85 with a weight decay of 0.1 for the encoder.

The design specifications of Sapiens are detailed in the following table. Following a specific approach, Sapiens prioritizes scaling models by width rather than depth. Notably, the Sapiens-0.3B model, while architecturally similar to the traditional ViT-Large, consists of twentyfold more FLOPs due to its higher resolution.

Sapiens is fine-tuned for face, body, feet, and hand (K = 308) pose estimation using high-fidelity annotations. For training, Sapiens uses the train set with 1M images, and for evaluation, it uses the test set, named Humans5K, with 5K images. The evaluation follows a top-down approach, where Sapiens uses an off-the-shelf detector for bounding boxes and conducts single human pose inference. Table 3 shows a comparison of Sapiens models with existing methods for whole-body pose estimation. All methods are evaluated on 114 common key points between Sapiens’ 308 key point vocabulary and the 133 key point vocabulary from COCO-WholeBody. Sapiens-0.6B surpasses the current state-of-the-art, DWPose-l, by +2.8 AP. Unlike DWPose, which utilizes a complex student-teacher framework with feature distillation tailored for the task, Sapiens adopts a general encoder-decoder architecture with large human-centric pretraining.

Interestingly, even with the same parameter count, Sapiens models demonstrate superior performance compared to their counterparts. For instance, Sapiens-0.3B exceeds VitPose+-L by +5.6 AP, and Sapiens-0.6B outperforms VitPose+-H by +7.9 AP. Within the Sapiens family, results indicate a direct correlation between model size and performance. Sapiens-2B sets a new state-of-the-art with 61.1 AP, a significant improvement of +7.6 AP over the prior art. Despite fine-tuning with annotations from an indoor capture studio, Sapiens demonstrates robust generalization to real-world scenarios, as shown in the following figure.

Sapiens is fine-tuned and evaluated using a segmentation vocabulary of 28 classes. The train set consists of 100K images, while the test set, Humans-2K, consists of 2K images. Sapiens is compared with existing body-part segmentation methods fine-tuned on the same train set, using the suggested pretrained checkpoints by each method as initialization. Similar to pose estimation, Sapiens shows generalization in segmentation, as demonstrated in the following table.

Interestingly, the smallest model, Sapiens-0.3B, outperforms existing state-of-the-art segmentation methods like Mask2Former and DeepLabV3+ by 12.6 mIoU due to its higher resolution and large human-centric pretraining. Furthermore, increasing the model size further improves segmentation performance. Sapiens-2B achieves the best performance, with 81.2 mIoU and 89.4 mAcc on the test set, in the following figure shows the qualitative results of Sapiens models.

Conclusion

Sapiens represents a significant step toward advancing human-centric vision models into the realm of foundation models. Sapiens models demonstrate strong generalization capabilities across a variety of human-centric tasks. The state-of-the-art performance is attributed to: (i) large-scale pretraining on a curated dataset specifically tailored to understanding humans, (ii) scaled high-resolution and high-capacity vision transformer backbones, and (iii) high-quality annotations on augmented studio and synthetic data. Sapiens models have the potential to become a key building block for a multitude of downstream tasks and provide access to high-quality vision backbones to a significantly wider part of the community. 

[amcodritsolutions]

Angular vs. React vs. Vue: Which Framework Dominates in 2024?

In 2024, the battle of JavaScript frameworks continues to be dominated by Angular vs. React vs. Vue, each bringing unique strengths to front-end development. Angular, backed by Google, remains a powerhouse with its comprehensive feature set and strong enterprise support. It excels in complex, large-scale applications requiring robust architecture and TypeScript integration.

React, maintained by Facebook, retains its popularity for its flexibility and virtual DOM efficiency, making it ideal for building interactive user interfaces. Its vast ecosystem and component-based structure empower developers to create scalable applications swiftly.

Meanwhile, Vue.js, known for its simplicity and ease of integration, has steadily gained ground with its progressive framework approach. It appeals to developers seeking a lightweight yet powerful solution for building modern UIs and single-page applications.

The decision between Angular, React, and Vue hinges primarily on the specific project demands, the proficiency of the team, and the scalability requirements. While Angular suits enterprise-grade applications, React’s flexibility caters well to diverse project scopes, and Vue’s simplicity attracts startups and small teams aiming for rapid development. In 2024, these three remain the cornerstone choices in the ever-evolving landscape of front-end development.